package com.yy.wga.common.util.common;

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.text.DecimalFormat;
import java.text.NumberFormat;
import java.util.Random;

import static java.util.regex.Pattern.matches;

/**
 * 数字工具类
 *
 * @author <a href="mailto:ludezheng@hongrz.com"> ludezh </a>
 * @version 1.0.0   2018/10/7,15:43
 * @since 1.0.0     2018/10/7,15:43
 */
public class NumberUtils {
    /**
     * 数字开头正则
     */
    public static final String NUM = "[0-9]*";
    /**
     * 数字正则，包含小数
     */
    public static final String DOUBLE_NUM = "^[+-]?\\d+(\\.\\d)?$";

    /**
     * 默认数值。0.00
     */
    public final static String ZERO_BALANCE = "0.00";
    /**
     * 默认数值。0.0
     */
    public final static String ZERO_BALANCE_SINGLE = "0.0";

    public final static String SINGLE_ZERO_BALANCE_SINGLE = "0";

    /**
     * 百分之 100
     */
    public final static double FULL_PERCENT = 100d;

    /**
     * 生成随机randNum位数---随机密码用的
     *
     * @return
     */
    public static String getRandom(int randNum) {
        Random r = new Random();
        return getNumStr(String.valueOf(r.nextInt() * 10), randNum);
    }

    public static String getNumStr(String numStr, int randNum) {
        StringBuffer sbSysTrace = new StringBuffer("000000").append(numStr);
        String systrace = sbSysTrace.substring(sbSysTrace.length() - randNum, sbSysTrace.length());
        return systrace;
    }

    /**
     * 获取某范围内的随机整数
     *
     * @param min
     * @param max
     * @return
     */
    public static int getIntRandom(int min, int max) {
        Random random = new Random();
        return random.nextInt(max) % (max - min + 1) + min;
    }

    public static int str2Integer(String numStr) {
        int num = 0;
        try {
            num = Integer.valueOf(numStr.trim());
        } catch (Exception e) {
            num = 0;
        }
        return num;
    }

    /**
     * 获取两个数的百分比
     *
     * @param num1
     * @param num2
     * @return
     */
    public static String getPercentFormat(int num1, int num2) {
        // 创建一个数值格式化对象
        NumberFormat numberFormat = NumberFormat.getInstance();
        // 设置精确到小数点后2位  
        numberFormat.setMaximumFractionDigits(2);
        String result = numberFormat.format((float) num1 / (float) num2 * 100);
        return result;
    }

    /**
     * 默认保留2位小数
     *
     * @param price
     * @return
     */
    public static float getPriceFormat(float price) {
        return getPriceFormat(price, 2);
    }

    /**
     * @param price
     * @param scale 几位小数
     * @return
     */
    public static float getPriceFormat(float price, int scale) {
        BigDecimal b = new BigDecimal(price);
        float f1 = b.setScale(scale, RoundingMode.HALF_UP).floatValue();
        return f1;
    }

    /**
     * a pseudorandom double greater than or equal to 0.0 and less than 1.0.
     * 即返回一个[0,1)的double类型的随机数
     * 以下情况 |　y>x
     * double随机数
     * <p>
     * 要获取一个[x,y)的double类型的随机数 | 左闭右开
     * double d = x + Math.random() * (y - x);
     * <p>
     * 要获取一个(x,y]的double类型的随机数 | 左开右闭
     * double d = y - Math.random() * (y - x);
     * <p>
     * 要获取一个[x,y]的double类型的随机数 | 左闭右闭
     * double d = x + Math.random() * y % (y - x + 1);
     * <p>
     * 要获取一个(x,y)的double类型的随机数 | 左开右开
     * double d = (y - Math.random()) % y;
     *
     * @param min
     * @param max
     * @return
     */
    public static double getRandomDouble(int min, int max) {
        double d = min + Math.random() * max % (max - min + 1);
        return d;
    }

    public static double getRandomDouble(double min, double max) {
        double d = min + Math.random() * max % (max - min + 1);
        return d;
    }

    public static float getRandomFloat(float min, float max) {
        float d = (float) (min + Math.random() * max % (max - min + 1));
        return d;
    }

    /**
     * 获取范围内随机数
     *
     * @param min
     * @param max
     * @return
     */
    public static int getRandom(int min, int max) {
        Random random = new Random();
        int num = random.nextInt(max) % (max - min + 1) + min;
        return num;
    }

    /**
     * 是否为数字
     *
     * @return
     */
    public static boolean isNumeric(String str) {
        if (!matches(NUM, str)) {
            return false;
        }
        return true;
    }

    /**
     * 是否为数字，包含浮点型
     *
     * @param hasDouble 是否包含浮点型
     * @return
     */
    public static boolean isNumeric(String str, boolean hasDouble) {
        if (hasDouble) {
            return matches(DOUBLE_NUM, str);
        } else {
            return matches(NUM, str);
        }
    }

    public static int doubleToInt(String rate) {
        double d = Double.valueOf(rate);
        return (int) d;
    }

    /**
     * 元转分，确保price保留两位有效数字
     *
     * @return
     */
    public static int changeY2F(double price) {
        DecimalFormat df = new DecimalFormat("#.00");
        price = Double.parseDouble(df.format(price));
        int money = (int) (price * 100);
        return money;
    }

    /**
     * 分转元，转换为bigDecimal在toString
     *
     * @return
     */
    public static String changeF2Y(int price) {
        return BigDecimal.valueOf(price).divide(new BigDecimal(100)).toString();
    }


    /**
     * 有两位小数，且第二位小数为0时，显示 1位小数。
     * 有两位小数，且第二位小数非0时，显示 2位小数。
     * 金额 0 显示为  0.0
     * 非金额 0 显示为 0
     *
     * @param number
     * @return
     */
    public static String formatZero(String number) {
        if (StringUtils.isNotBlank(number)) {
            if (number.endsWith(SINGLE_ZERO_BALANCE_SINGLE)) {
                while (number.contains(".") && (number.length() - 2 > number.indexOf("."))) {
                    number = number.substring(0, number.length() - 1);
                }
            } else {
                while (!number.contains(".")) {
                    number += "." + SINGLE_ZERO_BALANCE_SINGLE;
                }
            }
        }
        return number;
    }

    /**
     * 有两位小数，且第二位小数为0时，显示 1位小数。
     * 有两位小数，且第二位小数非0时，显示 2位小数。
     * 金额 0 显示为  0.0
     * 非金额 0 显示为 0
     *
     * @param number
     * @return
     */
    public static String formatZero(BigDecimal number) {
        return formatZero(floorNumber(number));
    }

    /**
     * 去除小数位所有的末尾0
     * 1.01 结果 1.01
     * 1.10 结果 1.1
     * 1.00 结果 1
     *
     * @param number
     * @return
     */
    public static String stripTrailingZeros(BigDecimal number) {
        if (number == null) {
            return SINGLE_ZERO_BALANCE_SINGLE;
        }
        return number.stripTrailingZeros().toPlainString();
    }

    /**
     * 去除小数位所有的末尾0
     * 1.01 结果 1.01
     * 1.10 结果 1.1
     * 1.00 结果 1
     *
     * @param number 非正常数会报错，如a.bc
     * @return
     */
    public static String stripTrailingZeros(String number) {
        if (StringUtils.isNotBlank(number)) {
            return stripTrailingZeros(new BigDecimal(number));
        }
        return SINGLE_ZERO_BALANCE_SINGLE;
    }


    /**
     * 数
     *
     * @param num
     * @return
     */
    public static BigDecimal roundNumber(BigDecimal num) {
        num = num.setScale(2, RoundingMode.DOWN);
        return num;
    }

    /**
     * 向下取整两位小数
     *
     * @param num
     * @return
     */
    public static String floorNumber(BigDecimal num) {
        if (num == null) {
            return ZERO_BALANCE;
        } else {
            return num.setScale(2, RoundingMode.FLOOR).toString();
        }
    }


}

